함수 만들기 | ✅저자: 이유정(박사)

🔹 함수 (define )

함수(Function)는 "코드를 묶어서 이름을 붙여놓은 것"이에요.  
필요할 때 그 이름을 호출해서 안에 있는 코드를 실행할 수 있습니다.

📘 대부분의 프로그래밍 언어에서 함수는 function이라고 부르며,
Java, C#, Kotlin 같은 클래스 기반 언어에서는 클래스 내부에 정의된 함수를
method(메서드)라고 부르지만, 기능적으로는 모두 함수(Function)입니다.

◽ 함수의 장점

• 반복되는 코드를 줄일 수 있어요.
• 코드를 읽기 쉽고 정리하기 쉬워요.
• 유지보수나 수정이 쉬워져요.
• 모듈화(modularization)가 가능해요.

🔹 함수 정의 (Function Definition) 특정 작업을 수행하는 코드 블록에 이름을 붙여 저장하는 것을 말합니다. 즉, 자주 사용하는 코드나 반복되는 작업을 하나로 묶어서 필요할 때마다 호출해서 쓸 수 있도록 만드는 것입니다. 함수를 정의하면 프로그램을 더 간단하게, 재사용 가능하게, 읽기 쉽게 만들 수 있습니다.

📖 문법, 구문(syntax):

# 함수정의 및 매개변수 Parameter
def 함수이름(매개변수):
	실행문

# 함수호출 (Function Call)
함수이름(인자) # Argument

🔹 함수와 함수 호출(Function Call) 정의된 함수를 실행시키기 위해 이름과 인자를 사용하는 것

</> 예시코드:

def add(a, b):
    return a + b

result = add(3, 4)
print(result)

🖨️ 출력결과:

7

📖 용어 및 설명 :

🔹 입력값이 없는 함수(Function)

입력값(매개변수) 없이 실행되는 함수입니다.  
호출 시 단순히 함수 내부에 작성된 작업을 바로 실행합니다.

</> 예시코드:

def say_hello():
    print("안녕하세요! 함수 공부를 시작해볼까요?")
	
say_hello()

🖨️ 출력결과:

안녕하세요! 함수 공부를 시작해볼까요?

💬 보충설명:

• def say_hello():는 매개변수를 받지 않는 함수 정의입니다.
• 함수 내부에는 단순히 print() 명령이 들어 있습니다.
• 호출 시 say_hello()처럼 괄호는 반드시 붙여야 실행됩니다.
• 입력이 필요 없고, 고정된 동작을 반복적으로 수행할 때 유용합니다.

🔹 매개변수(Parameter)

함수 정의 시, 함수 내부에서 사용할 값을 외부로부터 받기 위해 괄호 안에 지정하는 변수입니다.

</> 예시코드:

def greet(name):
    print(f"안녕하세요, {name}님!")

🖨️ 출력결과:

안녕하세요, 철수님!

❌ 인자를 전달하지 않은 경우 함수는 매개변수를 필요로 하지만, 호출 시 인자를 생략한 경우

</> 오류 예시코드:

def greet(name):
    print(f"안녕하세요, {name}님!")

greet()

❌ 🖨️ 오류메시지:

TypeError: greet() missing 1 required positional argument: 'name'

❓ 원인:

• greet() 함수는 name이라는 필수 매개변수가 필요한데, 인자를 전달하지 않아서 오류 발생
• 해결: greet("철수")처럼 인자를 반드시 전달해야 함

❌ 매개변수가 너무 많이 전달된 경우 함수가 받을 수 있는 매개변수보다 더 많은 인자를 넘긴 경우

</> 예시코드:

def greet(name):
    print(f"안녕하세요, {name}님!")

greet("철수", "영희")

❌ 🖨️ 오류메시지:

TypeError: greet() takes 1 positional argument but 2 were given

❓ 원인:

• 함수는 하나의 인자(name)만 받는데 두 개를 넘겨서 오류 발생
• 해결: 인자의 개수를 맞춰야 함 → greet("철수")

❌ 매개변수 이름을 잘못 입력했을 때 (키워드 인자 오류)

</> 오류 예시코드:

def greet(name):
    print(f"안녕하세요, {name}님!")

greet(nam="철수")

❌ 🖨️ 오류메시지:

TypeError: greet() got an unexpected keyword argument 'nam'

❓ 원인:

• nam은 오타. 함수 정의에는 name이라는 매개변수가 있으므로 정확한 이름 사용 필요
• 해결: greet(name="철수")처럼 정확히 일치시켜야 함

❌ 기본값 매개변수 위치 오류 기본값이 앞에 오면 안됩니다.

</> 오류 예시코드:

def greet(name="손님", message):
    print(f"{name}님, {message}")

❌ 🖨️ 오류메시지:

SyntaxError: non-default argument follows default argument

❓ 원인:

• 기본값이 있는 매개변수는 항상 뒤에 와야 합니다.
• 해결: def greet(message, name="손님")처럼 작성해야 함

📝 문제1] 오류가 발생하는 hello 함수 호출로 올바른 호출 방법으로 다시 작성해보세요.

def hello(name):
    print(f"{name}님, 반갑습니다!")

hello()

❌ 🖨️ 출력결과:

TypeError: hello() missing 1 required positional argument: 'name'

✅ 정답 코드:

def hello(name):
    print(f"{name}님, 반갑습니다!")

hello("지민")

✅ 또는 기본값을 주는 방법 (안전한 개선):

def hello(name="손님"):
    print(f"{name}님, 반갑습니다!")

hello()
hello("지민")

🖨️ 출력결과:

손님님, 반갑습니다!
지민님, 반갑습니다!

📝 문제2] introduce()라는 함수를 만들어, 이름(name)과 나이(age)를 전달받아 "{name}님의 나이는 {age}살입니다."를 출력하도록 하세요.

introduce("영희", 20)

🖨️ 출력결과:

영희님의 나이는 20살입니다.

✅ 정답 코드:

def introduce(name, age):
    print(f"{name}님의 나이는 {age}살입니다.")

introduce("영희", 20)

🔍 해설:

• name, age는 각각 문자열, 정수 타입의 매개변수입니다.
• 함수를 호출할 때 "영희"와 20을 각각 순서대로 넣습니다.
• 함수 내부에서는 print() 문에서 둘 다 f-string으로 출력됩니다.

📝 문제3] 이름과 도시를 전달받는 greet() 함수를 만드세요.
단, 도시(city)는 생략하면 "서울"을 기본값으로 사용합니다.

greet("민수")
greet("지현", "부산")

🖨️ 출력결과:

민수님은 서울에 살고 있습니다.
지현님은 부산에 살고 있습니다.

✅ 정답 코드:

def greet(name, city="서울"):
    print(f"{name}님은 {city}에 살고 있습니다.")

greet("민수")
greet("지현", "부산")

🔍 해설:

• city="서울"은 기본값 매개변수(Default Parameter)입니다.
• 첫 번째 호출 greet("민수")에서는 도시를 생략했기 때문에 자동으로 "서울"이 들어갑니다.
• 두 번째 호출에서는 "부산"을 직접 전달했기 때문에 기본값이 무시되고 "부산"이 출력됩니다.
• 이렇게 기본값을 주면 매번 모든 값을 넣지 않아도 되어 매우 유용합니다.

🔹 인자(Argument, 전달인자)

함수를 호출할 때 함수에 전달하는 실제 값을 말합니다.

</> 예시코드:

def greet(name):
	print(f"안녕하세요, {name}님!")
	
greet("철수")

🖨️ 출력결과:

안녕하세요, 철수님!

❌ 인자 개수를 잘못 전달한 경우

</> 오류 예시코드:

def greet(name, age):
    print(f"{name}님은 {age}세입니다.")

greet("철수")  # 나이 인자를 빠뜨림

❌ 🖨️ 출력결과:

TypeError: greet() missing 1 required positional argument: 'age'

❓원인:

• 함수는 두 개의 인자 name, age를 필요로 하지만 "철수" 하나만 전달되어 오류 발생
• 위치 인자는 순서대로 정확히 모두 전달해야 함

✅ 해결:

greet("철수", 25)

❌ 불필요한 인자를 더 전달한 경우

</> 오류 예시코드:

def greet(name):
    print(f"안녕하세요, {name}님!")

greet("철수", "영희")

❌ 🖨️ 출력결과:

TypeError: greet() takes 1 positional argument but 2 were given

❓원인: 함수는 인자 1개만 받도록 정의됐는데, 2개를 전달했기 때문에 오류 발생

✅ 해결:

greet("철수")

❌ 키워드 인자 이름을 잘못 쓴 경우

</> 오류 예시코드:

def greet(name):
    print(f"{name}님 안녕하세요!")

greet(nam="철수")

❌ 🖨️ 출력결과:

TypeError: greet() got an unexpected keyword argument 'nam'

❓원인: 함수는 name이라는 매개변수를 기대하고 있지만, nam이라는 잘못된 이름을 전달함

✅ 해결:

greet(name="철수")

❌ 인자를 중복으로 전달한 경우 (위치 + 키워드)

</> 오류 예시코드:

def greet(name):
    print(f"{name}님 반갑습니다.")

greet("철수", name="영희")

❌ 🖨️ 출력결과:

TypeError: greet() got multiple values for argument 'name'

❓원인: name 자리에 "철수"라는 위치 인자와 name="영희"라는 키워드 인자를 동시에 전달해서 중복 충돌 발생

✅ 해결:

greet("철수")  # 또는 greet(name="영희")

📝 문제1] 인자를 전달하지 않아 오류가 발생하는 경우 welcome() 함수를 정의하고 이름을 출력하려고 했지만, 인자를 전달하지 않아 오류가 발생합니다. 오류의 원인을 찾고 수정하세요.

def welcome(name):
    print(f"{name}님, 환영합니다!")

welcome()

❌ 🖨️ 출력 결과:

TypeError: welcome() missing 1 required positional argument: 'name'

✅ 수정 코드1:

welcome("지수")

✅ 수정 코드2:

def welcome(name="방문자"):
    print(f"{name}님, 환영합니다!")

welcome()         # 기본값 사용
welcome("지수")    # 사용자 입력값 사용

🔍 해설:

• welcome() 함수는 name이라는 필수 매개변수를 가지고 있습니다.
• 하지만 호출할 때 welcome()처럼 아무 인자도 전달하지 않았기 때문에 오류가 발생합니다.
• 이 오류는 필수값을 생략해서 생기는 대표적인 인자 전달 오류입니다.

📝 문제2] order_menu() 함수를 만들고, 손님 이름과 주문한 메뉴를 인자로 받아 "{name}님이 {menu}를 주문하셨습니다." 라고 출력하게 하세요.

order_menu("태현", "아메리카노")

🖨️ 출력 결과:

태현님이 아메리카노를 주문하셨습니다.

✅ 정답 코드:

def order_menu(name, menu):
    print(f"{name}님이 {menu}를 주문하셨습니다.")

order_menu("태현", "아메리카노")

🔍 해설:

• "태현"과 "아메리카노"는 각각 name, menu라는 매개변수로 전달됩니다.
• 이렇게 여러 개의 인자도 위치에 맞게 전달하면 정상 작동합니다.
• 인자의 순서가 중요합니다. (name, menu 순서대로 받아야 올바르게 출력됨)

📝 문제3] user_info() 함수는 이름(name), 나이(age), 도시(city)를 인자로 받습니다. 단, city는 생략 가능하며 기본값은 "서울"입니다.
이 함수를 호출할 때 키워드 인자(keyword arguments)를 사용해 순서를 바꿔 전달해보세요.

user_info(age=30, name="은우")
user_info(name="서윤", city="부산", age=22)

🖨️ 출력 결과:

은우님의 나이는 30세이고, 서울에 살고 있습니다.
서윤님의 나이는 22세이고, 부산에 살고 있습니다.

✅ 정답 코드:

def user_info(name, age, city="서울"):
    print(f"{name}님의 나이는 {age}세이고, {city}에 살고 있습니다.")

user_info(age=30, name="은우")
user_info(name="서윤", city="부산", age=22)

🔍 해설:

• 함수 호출 시 name="서윤"처럼 key=value 형식으로 값을 전달하는 방식 → 키워드 인자입니다.
• 이 방식은 전달 순서를 바꿔도 동작하므로 매우 유용합니다.
• city="서울"은 기본값 매개변수이기 때문에 생략 가능하며, 값을 넣으면 덮어씌워집니다.
• 초보자 입장에서 인자의 종류와 전달 방식(위치 vs 키워드)에 대해 깊이 이해할 수 있는 구조입니다.

🔹 반환값(Return Value) 자료와 함께 return하기

함수 실행 후 바깥으로 전달되는 결과값을 말합니다.

◽ return 생략된 함수 함수 내부에 return 문이 아예 없을 경우, 함수는 작업을 마친 후 자동으로 None을 반환합니다.
→ 값을 돌려주지 않고 출력만 하는 함수에 주로 사용됩니다.

</> 예시코드: return 생략된 함수

def greet():
    print("안녕하세요!")

result = greet()
print(result)

🖨️ 출력:

안녕하세요!
None

• return이 없으므로 None이 자동 반환됩니다.

◽ return만 사용한 경우 return 키워드는 있지만 반환값이 없는 경우입니다.
→ 함수 실행을 즉시 종료시키고 None을 반환합니다.
→ 특정 조건에서 실행을 멈추고 싶을 때 사용됩니다.

</> 예시코드: return만 사용한 경우

def check_even(n):
    if n % 2 != 0:
        return  # 짝수가 아니면 종료
    print("짝수입니다.")

• 조건에 따라 조기 종료되며 값은 반환하지 않음 → None 반환됨.

◽ 값 1개 반환 하나의 값(숫자, 문자열, 리스트 등)을 반환합니다.
→ 호출한 쪽에서 그 값을 받아서 계산, 출력, 저장 등에 활용할 수 있음. → 가장 기본적인 return 형태입니다.

</> 예시코드: 값 1개 반환

def get_name():
    return "Eunice"

name = get_name()
print(name)

🖨️ 출력:

Eunice

• 문자열 1개 반환

◽ 여러 값 반환 (튜플) 값을 여러 개 나열하여 반환하면 자동으로 튜플(tuple)로 묶여서 하나의 값처럼 반환됩니다.
→ 다양한 정보를 한 번에 돌려줄 때 유용합니다.

</> 예시코드:

def calc(x, y):
    return x + y, x * y

sum_val, mul_val = calc(3, 5)
print(sum_val, mul_val)

🖨️ 출력:

8 15

• return x + y, x * y → 튜플 (8, 15) 반환 → 언패킹

◽ 조건부 반환 if, else 등의 조건에 따라 서로 다른 값이나 행동을 반환합니다.
→ 상황에 따라 다른 결과를 제공하며, 함수의 유연성을 높이는 방식입니다.

</> 예시코드:

def safe_divide(x, y):
    if y == 0:
        return None
    return x / y

print(safe_divide(10, 2))  # 5.0
print(safe_divide(10, 0))  # None

🖨️ 출력:

조건에 따라 다른 반환값

• 조건에 따라 다른 반환값

◽ 객체 또는 함수 반환 함수에서 숫자나 문자열이 아닌 다른 함수나 객체를 반환할 수 있습니다.
→ 주로 고차 함수, 팩토리 함수, 클로저를 만들 때 사용되며, 유연하고 동적인 함수 설계가 가능합니다.

</> 예시코드:

def make_multiplier(n):
    def multiplier(x):
        return x * n
    return multiplier

double = make_multiplier(2)
print(double(5))  # 10

• 함수 내부에서 다른 함수를 반환 (고차 함수)

◽ return은 함수 실행 종료도 포함 조건을 만족하면 return을 이용해 함수 실행을 중간에 멈추고 빠져나옵니다.
→ 불필요한 계산을 줄이거나 예외 상황을 빠르게 처리할 때 사용됩니다.

</> 예시코드:

def show_numbers():
    print("1")
    return
    print("2")  # 실행되지 않음

show_numbers()

🖨️ 출력:

1

• return 뒤의 코드는 실행되지 않음 (함수 종료)

❌ return을 빼먹은 경우 – 결과값이 None이 되는 오류

</> 오류 예시코드:

def multiply(x, y):
    result = x * y  # 계산은 했지만 return 없음

print(multiply(2, 5))

❌ 🖨️ 출력결과:

None

❓ 원인:

• 함수 내부에서 x * y는 계산되었지만, return으로 돌려주지 않았기 때문에 함수의 반환값은 자동으로 None이 됩니다.
• print()는 None을 출력함.

✅ 해결 방법:

def multiply(x, y):
    return x * y

print(multiply(2, 5))  # → 10

❌ return 값을 받지 않고 그냥 버리는 경우

</> 오류 예시코드:

def add(x, y):
    return x + y

add(10, 5)  # 값을 받지 않고 출력도 안함

❌ 🖨️ 출력결과:

(아무것도 출력되지 않음)

❓ 원인:

• 함수는 15를 반환했지만, 반환값을 변수에 저장하거나 출력하지 않았기 때문에 아무 일도 안 한 것처럼 보임.
• 문법적 오류는 없지만 논리적 오류(출력 없음).

✅ 해결 방법:

result = add(10, 5)
print(result)  # → 15

❌ 3. return 값을 여러 개 받는 과정에서 언패킹 오류

</> 오류 예시코드:

def get_user():
    return "지민", 25

name = get_user()  # 튜플 전체가 name에 저장됨
print(name)        # 출력은 튜플
print(age)         # 오류 발생

❌ 🖨️ 출력결과:

NameError: name 'age' is not defined

❓ 원인:

• 반환값은 2개지만 하나의 변수에만 저장함 → 튜플로 묶여 name에 저장됨
• age는 아예 정의되지 않았기 때문에 NameError 발생

✅ 해결 방법:

name, age = get_user()
print(name)  # → 지민
print(age)   # → 25

📝 문제1] return을 작성하지 않아 결과가 출력되지 않는 경우 add_numbers() 함수는 숫자 2개를 받아 더하는 함수입니다.
하지만 이 코드는 함수에서 결과를 반환하지 않아 출력이 잘못됩니다.
출력 결과를 예상하고, 오류를 수정하세요.

def add_numbers(a, b):
    total = a + b   # 계산은 했지만 return이 없음

print(add_numbers(3, 7))

🖨️ 출력 결과:

None

✅ 수정된 코드:

def add_numbers(a, b):
    return a + b  # 계산 결과를 함수 밖으로 돌려줌

print(add_numbers(3, 7)) # 10

🔍 해설:

• 함수 내부에서 a + b를 계산하여 total에 저장했지만, return문이 없기 때문에 함수는 자동으로 None을 반환하게 됩니다.
• print()는 None을 출력하게 되어 결과가 기대와 달라집니다.

📝 문제2] make_sentence() 함수는 이름(name)과 직업(job)을 받아
"{name}님은 {job}입니다."라는 문장을 문자열로 반환합니다.
아래와 같은 결과가 출력되도록 함수를 작성하세요.

print(make_sentence("하늘", "디자이너"))

🖨️ 출력 결과:

하늘님은 디자이너입니다.

✅ 정답 코드:

def make_sentence(name, job):
    return f"{name}님은 {job}입니다."

print(make_sentence("하늘", "디자이너"))

🔍 해설:

• 이 문제는 단순한 계산이 아닌 문자열을 반환하는 함수입니다.
• 함수 안에서 f-string을 사용하여 문장을 만들고, return으로 돌려줍니다.
• 함수 밖에서는 그 반환값을 print()로 출력하고 있습니다.
• 초보자가 숫자뿐만 아니라 문자열도 반환할 수 있다는 점을 익힐 수 있는 문제입니다.

📝 문제3] check_even() 함수는 하나의 정수(num)를 받아
짝수면 "짝수입니다.", 홀수면 "홀수입니다."라는 문장을 반환합니다.
단, 함수 안에서는 if 조건문을 사용해야 합니다.

result1 = check_even(8)
result2 = check_even(13)

print(result1)
print(result2)

🖨️ 출력 결과:

짝수입니다.
홀수입니다.

✅ 정답 코드:

def check_even(num):
    if num % 2 == 0:
        return "짝수입니다."
    else:
        return "홀수입니다."

result1 = check_even(8)
result2 = check_even(13)

print(result1)
print(result2)

🔍 해설:

• num % 2 == 0은 짝수인지 검사하는 조건문입니다.
• 조건에 따라 서로 다른 문자열을 return합니다.
• print()는 반환된 값을 출력만 할 뿐입니다.
• 이 문제는 반환값을 만들기 위해 조건문과 return을 함께 사용하는 고급 로직입니다.
• 초보자가 조건 + 반환 로직을 자연스럽게 익힐 수 있도록 난이도를 높였습니다.

🔹 리턴문(Return Statement)

함수의 결과를 반환하고 실행을 종료하는 문장

</> 예시코드:

def is_adult(age):
    if age >= 20:
        return True
    return False

🖨️ 출력결과:

print(is_adult(18))  # False

◽ return만 사용했을 때

</> 예시코드:

def check_age(age):
    if age < 20:
        print("미성년자입니다.")
        return   # 값을 돌려주지 않고 함수만 종료함

    print("성인입니다.")

result = check_age(15)
print("함수 반환값:", result)

🖨️ 출력결과:

미성년자입니다.
함수 반환값: None

🔍 해설:

• return 뒤에 값이 없으므로 아무 것도 반환하지 않음
• 이럴 경우 파이썬은 자동으로 None을 반환
• check_age(15)는 함수 내부에서 "미성년자입니다."를 출력하고 즉시 종료**됨
• 반환값이 없으므로 result에는 None이 저장되어 print()에서 그대로 출력됨

◽ return이 함수 실행을 멈춘다는 개념

</> 함수정의:

def return_test():
    print("A 위치입니다.")
    return
    print("B 위치입니다.")

🔍 코드 해설: def return_test(): return_test라는 이름의 함수를 정의합니다. 괄호가 비어 있으므로 입력값은 없습니다.

print("A 위치입니다.") 함수가 실행되면 가장 먼저 출력되는 코드입니다.

return 여기서 함수 실행이 끝납니다. 이후의 코드는 무시됩니다.

print("B 위치입니다.") return 뒤에 있어서 절대 실행되지 않습니다. 이런 코드를 Dead Code(죽은 코드) 라고 부릅니다.

</> 함수호출:

return_test()

🖨️ 출력 결과

A 위치입니다.

return # 리턴 뒤로는 죽은 코드
print("B 위치입니다.") # 출력 안됨

◽ 아무것도 return하지 않기

</> 예시코드: return 자체가 없을 때

def greet(name):     
	print(f"안녕하세요, {name}님!") 
	 
result = greet("민수") 
print("결과:", result)

🖨️ 출력 결과:

안녕하세요, 민수님! 
결과: None

🔍 해설:

• 함수에 return이 없으면 → 파이썬은 자동으로 None을 반환
• print()는 실행되지만, 변수에는 아무 결과도 저장되지 않음

📝 문제1] greet() 함수는 이름(name)을 받아
"안녕하세요, {name}님!"이라는 인사말을 return합니다.
화면에 결과가 출력되도록 print()로 호출하세요.

print(greet("지우"))

🖨️ 출력 결과:

안녕하세요, 지우님!

✅ 정답 코드:

def greet(name):
    return f"안녕하세요, {name}님!"

print(greet("지우"))

🔍 해설:

• return은 결과값을 함수 밖으로 전달합니다.
• print()는 return으로 돌려받은 값을 출력합니다.
• 함수 내부에서 print()를 하지 않아도 return값은 외부에서 사용할 수 있습니다.

📝 문제2] grade_comment() 함수는 점수(score)를 받아
90점 이상이면 "우수",
60점 이상이면 "보통",
60점 미만이면 "노력 필요"를 반환합니다.

print(grade_comment(95))
print(grade_comment(75))
print(grade_comment(50))

🖨️ 출력 결과:

우수
보통
노력 필요

✅ 정답 코드:

def grade_comment(score):
    if score >= 90:
        return "우수"
    elif score >= 60:
        return "보통"
    else:
        return "노력 필요"

print(grade_comment(95))
print(grade_comment(75))
print(grade_comment(50))

🔍 해설:

• if, elif, else 조건에 따라 다른 문자열을 return합니다.
• return을 만나면 해당 분기의 처리를 마치고 함수 실행이 종료됩니다.
• 각각 다른 조건을 만족하는 점수에 따라 다르게 출력되는 것을 확인할 수 있습니다.

📝 문제3]
check_access(user_age, has_ticket) 함수는 두 가지 정보를 입력받습니다:

• 나이(user_age)가 18세 이상이고
• 티켓(has_ticket)이 있을 경우에만 "입장 가능"을 반환하고,
  그 외는 "입장 불가"를 반환합니다.

조건을 만족하면 바로 리턴(return)하여 함수를 종료하세요.

print(check_access(20, True))
print(check_access(16, True))
print(check_access(25, False))

🖨️ 출력 결과:

입장 가능
입장 불가
입장 불가

✅ 정답 코드:

def check_access(user_age, has_ticket):
    if user_age >= 18:
        if has_ticket:
            return "입장 가능"
    return "입장 불가"

print(check_access(20, True))
print(check_access(16, True))
print(check_access(25, False))

🔍 해설:

• user_age와 has_ticket 조건을 함께 확인하기 위해 중첩 조건문을 사용합니다.
• 조건을 만족하면 바로 "입장 가능"을 return하며 함수 실행이 종료됩니다.
• 조건을 만족하지 못하면 맨 마지막 줄의 "입장 불가"로 넘어가게 됩니다.
• 이 문제는 논리 판단 + 조기 종료(return) 개념을 함께 연습할 수 있는 고급 구조입니다.

📝 문제 4] check_login() 함수는 사용자 이름이 "admin"이 아니면
"접근 불가"를 출력하고 함수를 종료합니다.
반환값 없이 return만 사용했을 때 어떤 결과가 출력되는지 확인하세요.

result = check_login("guest")
print("반환값:", result)

🖨️ 출력 결과:

접근 불가
반환값: None

✅ 정답 코드:

def check_login(username):
    if username != "admin":
        print("접근 불가")
        return  # 값을 반환하지 않고 함수만 종료

    print("관리자 로그인 성공")

result = check_login("guest")
print("반환값:", result)

🔍 해설:

• username이 "admin"이 아니므로 조건문이 참이 되어 "접근 불가"가 출력됩니다.
• 이후 return 키워드는 아무 값도 반환하지 않기 때문에 자동으로 None을 반환합니다.
• 따라서 result 변수에는 None이 저장되고, print("반환값:", result)에서 그대로 출력됩니다.

🔹 기본값 매개변수(Default Parameter)

함수 정의 시 매개변수에 기본값을 지정하여 호출할 때 생략 가능하게 함

</> 예시코드:

def greet(name="손님"):
    print(f"{name}님, 어서오세요.")

🖨️ 출력결과:

greet()         # 손님님, 어서오세요.
greet("지민")    # 지민님, 어서오세요.

◽ 기본 매개변수 중에서 필요한 값만 입력하기

</> 예시코드: 일부 값은 생략하고, 필요한 값만 키워드로 전달

def travel(country="한국", city="서울", days=3):     
	print(f"{country}의 {city}에서 {days}일간 여행합니다.")  
	
travel(city="부산")

🖨️ 출력 결과:

한국의 부산에서 3일간 여행합니다.

🔍 해설:

• city="부산"만 전달 → 나머지 country, days는 기본값 사용
• 키워드 인자를 통해 원하는 것만 지정 가능

📝 문제1] say_hello() 함수는 이름(name)을 매개변수로 받으며, 기본값은 "방문자"입니다.
아래처럼 호출할 때 인자를 생략하면 "방문자"가 자동으로 사용되어야 합니다.

say_hello()
say_hello("민준")

🖨️ 출력 결과:

안녕하세요, 방문자님!
안녕하세요, 민준님!

✅ 정답 코드:

def say_hello(name="방문자"):
    print(f"안녕하세요, {name}님!")

say_hello()
say_hello("민준")

🔍 해설:

• name="방문자"는 기본값 매개변수로, 인자를 생략하면 "방문자"가 자동으로 사용됩니다.
• say_hello("민준")처럼 값을 넣으면 기본값이 무시되고 "민준"이 출력됩니다.
• 초보자가 함수 호출 시 인자를 생략해도 함수가 잘 작동하는 이유를 이해할 수 있습니다.

📝 문제2]
calculate_price() 함수는 상품 가격(price)과 배송비(shipping)를 받아
총 금액을 출력합니다. 단, 배송비의 기본값은 3000원입니다.

🖨️ 출력 결과:

총 결제 금액: 18000원
총 결제 금액: 15000원

✅ 정답 코드:

def calculate_price(price, shipping=3000):
    total = price + shipping
    print(f"총 결제 금액: {total}원")

calculate_price(15000)
calculate_price(15000, 0)

🔍 해설:

• 배송비를 생략하면 기본값 3000이 사용되어 15000 + 3000 = 18000원 출력됩니다.
• 두 번째 호출에서는 배송비를 0으로 직접 입력했기 때문에 총합은 그대로 15000원입니다.
• 이 문제는 기본값을 덮어쓸 수 있다는 것을 체험하게 합니다.

📝 문제3]
make_profile() 함수는 이름(name), 나이(age), 국적(nationality)을 매개변수로 받고, 기본값은 age=0, nationality="한국"입니다.
name만 필수로 전달하고 나머지는 생략하거나 바꿔서 호출해보세요.

print(make_profile("윤아"))
print(make_profile("제임스", 35, "미국"))

🖨️ 출력 결과:

윤아님의 나이는 0세이며, 국적은 한국입니다.
제임스님의 나이는 35세이며, 국적은 미국입니다.

✅ 정답 코드:

def make_profile(name, age=0, nationality="한국"):
    return f"{name}님의 나이는 {age}세이며, 국적은 {nationality}입니다."

print(make_profile("윤아"))
print(make_profile("제임스", 35, "미국"))

🔍 해설:

• 이 함수는 두 개의 기본값 매개변수를 갖고 있습니다.
• 첫 번째 호출에서는 age, nationality를 생략했기 때문에 기본값이 사용됩니다.
• 두 번째 호출에서는 세 값을 모두 전달했기 때문에 기본값이 무시됩니다.
• 이 문제는 초보자가 다중 기본값, 그리고 기본값의 우선순위와 덮어쓰기 원리를 심화 이해할 수 있도록 설계된 고급형 문제입니다.

🔹 키워드 인자(Keyword Argument)

함수를 호출할 때 매개변수=값 형식으로 지정하여 위치와 상관없이 
전달이 가능합니다.

</> 예시코드:

def introduce(name, age):
    print(f"{name}님은 {age}세입니다.")

introduce(age=30, name="영희")

🖨️ 출력결과:

영희님은 30세입니다.

❌ 존재하지 않는 매개변수 이름 사용 (오타)

</> 오류 예시코드:

def greet(name):
    print(f"안녕하세요, {name}님!")

greet(naem="지민")  # 오타!

❌ 🖨️ 출력결과:

TypeError: greet() got an unexpected keyword argument 'naem'

❓ 원인:

• 함수 정의에는 name이라는 매개변수가 있지만, 호출 시 naem이라는 오타가 있는 키워드 인자를 전달함

✅ 해결 방법:

greet(name="지민")  # 정확한 이름으로 작성

❌ 위치 인자와 키워드 인자를 중복 전달

</> 오류 예시코드:

def greet(name):
    print(f"안녕하세요, {name}님!")

greet("지민", name="영희")

❌ 🖨️ 출력결과:

TypeError: greet() got multiple values for argument 'name'

❓ 원인:

• "지민"은 name에 해당하는 위치 인자,
• name="영희"는 키워드 인자로 동일한 매개변수에 두 번 전달되어 충돌 발생

✅ 해결 방법:

greet("지민")  # 또는 greet(name="지민") 둘 중 하나만 사용해야 함

❌ 위치 인자 뒤에 키워드 인자를 쓰지 않고 순서가 어긋난 경우

</> 오류 예시코드:

def greet(name, age):
    print(f"{name}님은 {age}세입니다.")

greet(name="지민", 25)  # 위치 인자가 뒤에 있음

❌ 🖨️ 출력결과:

SyntaxError: positional argument follows keyword argument

❓ 원인:

• 키워드 인자가 먼저 오고, 위치 인자가 나중에 오면 문법 오류가 발생합니다.
• 위치 인자는 항상 앞쪽에 와야 합니다.

✅ 해결 방법:

greet("지민", 25)  # 위치 인자만 사용하거나
greet(name="지민", age=25)  # 모두 키워드 인자로 전달

📝 문제1] 키워드 인자에서 오류가 발생하는 경우 book_info() 함수는 책 제목(title)과 저자(author)를 인자로 받습니다.
아래 코드는 호출 시 키워드 인자의 이름을 잘못 사용하거나, 중복 전달로 인해 오류가 발생합니다. 오류를 찾고 수정하세요.

def book_info(title, author):
    print(f"'{title}'의 저자는 {author}입니다.")

book_info(title="해리포터", auther="조앤 롤링")

🖨️ 출력 결과:

TypeError: book_info() got an unexpected keyword argument 'auther'

✅ 수정된 정답 코드:

def book_info(title, author):
    print(f"'{title}'의 저자는 {author}입니다.")

book_info(title="해리포터", author="조앤 롤링")

🔍 해설:

• 함수는 author라는 매개변수 이름을 기대하고 있는데, 호출할 때 auther라고 잘못 입력함 (오타)
• 정의되지 않은 매개변수 이름으로 값을 전달하면 TypeError가 발생합니다.
• 이 오류는 초보자가 영어 단어를 오타내거나, 매개변수 이름을 정확히 기억하지 못할 때 자주 발생합니다.

📝 문제2] create_account() 함수는 사용자 이름(name), 나이(age), 도시(city)를 받습니다.
단, 도시(city)의 기본값은 "서울"입니다.
아래처럼 호출했을 때, 키워드 인자와 기본값이 올바르게 동작하도록 하세요.

create_account(name="성우", age=28)
create_account(age=35, name="소연", city="부산")

🖨️ 출력 결과:

성우님의 나이는 28세이고, 도시는 서울입니다.
소연님의 나이는 35세이고, 도시는 부산입니다.

✅ 정답 코드:

def create_account(name, age, city="서울"):
    print(f"{name}님의 나이는 {age}세이고, 도시는 {city}입니다.")

create_account(name="성우", age=28)
create_account(age=35, name="소연", city="부산")

🔍 해설:

• 첫 번째 호출에서는 city를 생략했으므로 기본값 "서울"이 사용됩니다.
• 두 번째 호출에서는 city="부산"으로 키워드 인자를 통해 직접 값을 전달했기 때문에 기본값이 무시됩니다.
• 이 문제는 기본값 매개변수와 키워드 인자 혼합 사용법을 익히는 데 적합합니다.

📝 문제3]
travel_plan() 함수는 세 개의 정보를 받습니다:

• 목적지(destination),
• 기간(days),
• 교통수단(transport)

아래와 같이 호출할 때, 매개변수의 순서가 전혀 다르게 작성되어 있어도
정확한 정보가 출력되도록 모두 키워드 인자로 전달하세요.

travel_plan(transport="기차", destination="부산", days=3)
travel_plan(days=5, transport="비행기", destination="제주도")

🖨️ 출력 결과:

목적지: 부산 / 기간: 3일 / 교통수단: 기차
목적지: 제주도 / 기간: 5일 / 교통수단: 비행기

✅ 정답 코드:

def travel_plan(destination, days, transport):
    print(f"목적지: {destination} / 기간: {days}일 / 교통수단: {transport}")

travel_plan(transport="기차", destination="부산", days=3)
travel_plan(days=5, transport="비행기", destination="제주도")

🔍 해설:

• 이 문제는 위치 인자를 사용하면 오류가 날 수 있는 구조입니다.
• destination, days, transport의 순서를 기억하지 않아도, 키워드 인자를 통해 명확하게 지정하면 안전하게 호출할 수 있습니다.
• 이 방식은 실수 방지, 가독성 향상, 유지보수성 측면에서 매우 유리합니다.
• 초보자가 키워드 인자의 강점을 명확하게 체감할 수 있도록 설계한 고급 문제입니다.

🔹 가변 인자(*args)

매개변수 개수를 정하지 않고 여러 값을 튜플로 받아 처리합니다.

</> 예시코드:

def total(*numbers):
    return sum(numbers)

print(total(1, 2, 3, 4, 5))

🖨️ 출력결과:

15

◽ 위치 기반 가변 인자 (*args)와 키워드 인자 함께 사용하기 *args 또는 *values 여러 개의 위치 인자를 튜플로 묶어 받는 매개변수입니다. 전달하는 값의 개수가 정해지지 않았을 때 사용합니다. n=2 기본값을 가진 키워드 인자입니다. 생략하면 자동으로 2가 들어갑니다.|

</> 예시코드:

def print_n_times(*values, n=2):
    for i in range(n):
        for value in values:
            print(value)
        print()  # 줄바꿈

</> 함수 호출:

print_n_times("안녕하세요", "즐거운", "파이썬 프로그래밍", n=3)

🖨️ 출력 결과

안녕하세요
즐거운
파이썬 프로그래밍

안녕하세요
즐거운
파이썬 프로그래밍

안녕하세요
즐거운
파이썬 프로그래밍

🔍 해설:

• "안녕하세요", "즐거운", "파이썬 프로그래밍" → 전부 *values로 전달됨 → values = ("안녕하세요", "즐거운", "파이썬 프로그래밍")
• n=3 → 키워드 인자이므로 세 번 반복
• 결과적으로, 전달된 문자열들을 세 번 반복하여 출력하게 됨
• print()는 줄바꿈 용도로 추가

❌ *args를 썼지만 값을 전달하지 않은 경우 (의도한 동작이지만 실수로 해석될 수 있음)

</> 오류 예시코드:

def total(*numbers):
    return sum(numbers)

print(total())  # 인자를 아무것도 전달하지 않음

❌ 🖨️ 출력결과:

0

❓ 오류는 아니지만 주의점:

• sum() 함수는 빈 튜플을 만나면 0을 반환하므로 오류는 발생하지 않지만,왜 결과가 0인지 혼란스러워할 수 있음
• 함수 호출 시 인자가 전달되지 않았음을 인식하고, 필요하다면 검사를 추가하는 것이 좋음

✅ 방어적 코드 추가 예시:

def total(*numbers):
    if not numbers:
        return "숫자를 하나 이상 입력하세요."
    return sum(numbers)

print(total())  # → "숫자를 하나 이상 입력하세요."

❌ *args를 받는 위치가 잘못된 경우

</> 예시 코드 (문법 오류):

def example(*args, a):  # 가변 인자가 먼저 오고 일반 인자가 뒤에 있음
    print(args, a)

❌ 🖨️ 출력결과:

SyntaxError: * argument may appear only once and must be last

❓ 원인:

• *args는 반드시 가장 마지막 위치 인자로 와야 함
• 뒤에 일반 위치 매개변수가 올 수 없기 때문에 문법 오류

✅ 해결 방법:

def example(a, *args):
    print(args, a)

❌ *args사용 시, 언패킹 없이 리스트 그대로 전달한 경우

</> 예시 코드 (의도와 다른 결과):

def total(*numbers):
    return sum(numbers)

nums = [1, 2, 3]
print(total(nums))  # 리스트 하나를 통째로 전달

❌ 🖨️ 오류 메시지:

TypeError: unsupported operand type(s) for +: 'int' and 'list'

❓ 원인:

• nums 리스트가 하나의 인자로 전달되어 numbers = ([1, 2, 3],)가 되고,
• sum()이 리스트를 더하려고 해서 오류 발생

✅ 해결 방법:

print(total(*nums))  # *를 붙이면 각 요소가 개별 인자로 전달됨

📝 문제1] 리스트를 그대로 전달해서 오류가 발생하는 경우 print_fruits() 함수는 여러 개의 과일 이름을 인자로 받아 출력합니다.
다음과 같이 리스트로 과일들을 전달하려고 했지만, 의도한 출력이 되지 않고 오류가 발생했습니다. 오류 원인을 찾고 코드를 수정하세요.

def print_fruits(*fruits):
    print("과일 목록:")
    for fruit in fruits:
        print("-", fruit)

fruit_list = ["사과", "바나나", "포도"]
print_fruits(fruit_list)

🖨️ 실제 출력 결과:

과일 목록:
- ['사과', '바나나', '포도']   ← ❌ 한 줄로 리스트 전체가 출력됨

🔍 오류 해설:

• print_fruits(fruit_list)는 *fruits에 리스트 하나가 통째로 전달됩니다. 즉, fruits = (["사과", "바나나", "포도"],)가 되어 fruit은 리스트 하나가 됩니다.
• 그래서 "과일 목록"이 아닌 "리스트 하나"만 출력됨
• 의도는 리스트의 각 요소를 개별 인자로 전달하는 것이므로, 리스트를 언패킹해야 함

✅ 수정된 정답 코드 (언패킹 사용):

def print_fruits(*fruits):
    print("과일 목록:")
    for fruit in fruits:
        print("-", fruit)

fruit_list = ["사과", "바나나", "포도"]
print_fruits(*fruit_list)  # 언패킹!

🖨️ 출력 결과:

과일 목록:
- 사과
- 바나나
- 포도

📝 문제2] find_max() 함수는 여러 숫자를 인자로 받아, 그 중 가장 큰 값을 찾아 출력합니다. 가변 인자를 사용해 다양한 숫자를 받을 수 있도록 하세요.

find_max(4, 10, 2, 99, 7)

🖨️ 출력 결과:

가장 큰 수는: 99

✅ 정답 코드:

def find_max(*numbers):
    max_value = max(numbers)
    print("가장 큰 수는:", max_value)

find_max(4, 10, 2, 99, 7)

🔍 해설:

• *numbers로 전달된 숫자들을 max() 함수에 넘겨서 최댓값을 구합니다.
• 가변 인자를 통해 숫자 개수 제한 없이 동작합니다.
• 초보자는 *args와 함께 내장 함수와 결합하여 문제를 해결하는 방식을 배울 수 있습니다.

📝 문제3] calculate_stats() 함수는 여러 숫자를 인자로 받아 총합과 평균을 함께 반환합니다.
이때, return을 사용해 두 값을 함께 돌려줘야 하며, print()로 결과를 출력하세요.

total, average = calculate_stats(80, 90, 100, 70)
print("총합:", total)
print("평균:", average)

🖨️ 출력 결과:

총합: 340
평균: 85.0

✅ 정답 코드:

def calculate_stats(*scores):
    total = sum(scores)
    average = total / len(scores)
    return total, average

total, average = calculate_stats(80, 90, 100, 70)
print("총합:", total)
print("평균:", average)

🔍 해설:

• *scores는 여러 개의 점수를 튜플로 받습니다.
• sum()으로 총합을 구하고, len()으로 개수를 구해 평균을 계산합니다.
• return total, average는 두 개의 값을 튜플로 한 번에 반환합니다.
• 호출할 때 total, average = calculate_stats(...)처럼 여러 변수로 분리해서 받는 unpacking도 함께 학습할 수 있는 고급 문제입니다.

🔹 가변 키워드 인자(**kwargs)

키워드 인자를 딕셔너리 형태로 받아 처리합니다.

</> 예시코드:

def user_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

user_info(name="민수", age=25, city="서울")

🔍해설:

• **info는 가변 키워드 인자를 뜻합니다.
• 함수 user_info를 호출할 때, key=value 형식으로 넘긴 인자들을 모두 모아서 → 딕셔너리로 저장합니다.
• 이 딕셔너리가 info입니다.

🖨️ 출력결과:

name: 민수
age: 25
city: 서울

❌ 일반 위치 인자를 key=value 없이 전달한 경우

</> 오류 예시코드:

def user_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

user_info("민수", 25, "서울")  # 전부 위치 인자

❌ 🖨️ 오류메시지:

TypeError: user_info() takes 0 positional arguments but 3 were given

❓ 원인:

• **kwargs는 오직 키워드 인자만 받도록 설계된 함수입니다.
• "민수", 25, "서울"은 모두 위치 인자이기 때문에 TypeError 발생

✅ 해결방법:

user_info(name="민수", age=25, city="서울")  # ← key=value 형식으로 전달해야 함

❌ 중복된 키워드 인자 전달 (명시적 + 딕셔너리 언패킹 충돌)

</> 오류 예시코드:

def user_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

extra = {"age": 25}
user_info(name="민수", age=30, **extra)

❌ 🖨️ 오류메시지:

TypeError: user_info() got multiple values for keyword argument 'age'

❓ 원인:

• age 키워드가 직접 명시된 인자와 **extra에서 중복**되어 전달됨
• Python은 중복된 키워드를 허용하지 않음

✅ 해결방법: 중복된 키 제거하거나, 하나의 소스만 사용

user_info(name="민수", **extra)  # 또는 user_info(name="민수", age=25)

❌ 딕셔너리를 언패킹하지 않고 그대로 전달한 경우

</> 오류 예시코드:

def user_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

data = {"name": "민수", "age": 25}
user_info(data)  # 언패킹 없이 전달

❌ 🖨️ 오류메시지:

TypeError: user_info() takes 0 positional arguments but 1 was given

❓ 원인:

• data는 딕셔너리지만 ** 언패킹을 하지 않으면 위치 인자로 전달되어 오류 발생

✅ 해결방법:

user_info(**data)  # 딕셔너리를 언팩하여 키워드 인자로 전달

📝 문제1] 가변 키워드 인자 사용 시 오류가 발생하는 경우 show_profile() 함수는 이름, 나이, 도시 등 다양한 정보를 받아 출력하는 함수입니다.
아래처럼 정보를 딕셔너리로 만들고 전달하려고 했지만, 오류가 발생합니다.
오류 원인을 찾고 코드를 수정하세요.

def show_profile(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

info = {"name": "지수", "age": 22, "hobby": "독서"}
show_profile(info)  # ❌ 오류 발생

🔍 오류설명:

• show_profile() 함수는 **kwargs를 사용하므로 키워드 인자만 받을 수 있습니다.
• info는 딕셔너리지만 언팩 없이 그대로 전달했기 때문에 위치 인자 1개로 처리되어 오류 발생
• **를 붙여야 info 딕셔너리의 각 키-값 쌍이 키워드 인자처럼 전달됩니다

🖨️ 출력 결과:

name: 지수
age: 22
hobby: 독서

✅ 수정된 정답 코드 (딕셔너리 언팩 사용):

def show_profile(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

info = {"name": "지수", "age": 22, "hobby": "독서"}
show_profile(**info)  # ✅ 언팩을 통해 키워드 인자로 전달

📝 문제2] product_info() 함수는 상품 정보를 key=value 형식으로 입력받아 출력 형식을 다음과 같이 맞춰야 합니다:

product_info(name="무선마우스", price=19000, brand="로지텍")

🖨️ 출력 결과:

[상품 정보]
name: 무선마우스
price: 19000
brand: 로지텍

✅ 정답 코드:

def product_info(**kwargs):
    print("[상품 정보]")
    for key, value in kwargs.items():
        print(f"{key}: {value}")

product_info(name="무선마우스", price=19000, brand="로지텍")

🔍 해설:

• **kwargs는 전달받은 키워드 인자를 딕셔너리 형태로 처리합니다.
• 반복문을 통해 딕셔너리 내용을 출력하며, 고정된 매개변수가 없기 때문에 유연하게 다양한 키를 처리할 수 있습니다.
• 함수의 시작에 고정된 문자열을 먼저 출력함으로써 출력을 더 구조화할 수 있습니다.

📝 문제3] secure_user_info() 함수는 사용자 정보를 받아 출력하지만,
password, token처럼 민감한 키는 출력하지 않도록 조건 필터링을 적용하세요.

secure_user_info(name="정우", email="jungwoo@example.com", password="abc123", token="xyz789")

🖨️ 출력 결과:

name: 정우
email: jungwoo@example.com

✅ 정답 코드:

def secure_user_info(**kwargs):
    private_keys = ["password", "token"]
    for key, value in kwargs.items():
        if key not in private_keys:
            print(f"{key}: {value}")

secure_user_info(
    name="정우", 
    email="jungwoo@example.com", 
    password="abc123", 
    token="xyz789"
)

🔍 해설:

• **kwargs로 받아온 키-값 중에서 password, token처럼 민감한 항목은 제외하고 출력해야 합니다.
• if key not in private_keys 조건을 걸어 보안 필터링을 수행합니다.
• 이 문제는 초보자가 **kwargs를 단순 출력 외에도 로직 제어에 활용할 수 있다는 점을 익히는 데 도움이 됩니다.
• 실무에서 민감한 데이터 처리 시 매우 중요한 패턴을 연습하게 됩니다.

</> 예시코드:

# 함수 정의 (introduce: 자기소개 함수 만들기)
             # 기본매개변수, 키워드인자, 가변인자,가변키워드
def introduce(name, age=18, *hobbies, **info): 
    # name: 필수 정보 (이름)
    # age: 생략 가능, 기본값은 18
    # *hobbies: 취미 여러 개를 받을 수 있음 (튜플로 저장)
    # **info: 추가 정보 (key=value 형식, 딕셔너리로 저장)
    
    print("이름:", name)
    print("나이:", age)
    
    print("취미 목록:")
    for hobby in hobbies:
        print("-", hobby)
    
    print("기타 정보:")
    for key, value in info.items():
        print(f"{key}: {value}")
    
    # 함수가 결과로 돌려주는 값
    return f"{name}님의 소개가 완료되었습니다!"


# 함수 호출 (introduce 함수 사용하기)
result = introduce(
    "Eunice", # 이름 (필수)
    25,  # 나이 (기본값 대신 25 사용)
    "독서", "여행", "코딩",# 취미 여러 개 전달하여 튜플로 받음
    job="개발자", city="서울" # 추가 정보는 키워드 인자로 전달
)

# 함수가 반환한 결과 출력
print("함수의 반환값:", result)

🖨️ 출력 결과:

이름: Eunice
나이: 25
취미 목록:
- 독서
- 여행
- 코딩
기타 정보:
job: 개발자
city: 서울
함수의 반환값: Eunice님의 소개가 완료되었습니다!

• return f"{name}님의 소개가 완료되었습니다!" 함수는 마지막에 리턴값을 돌려줍니다. 그 값은 result라는 변수에 저장됩니다. 그래서 화면에 결과가 나타납니다.

✅ 전체 흐름 요약 이 함수는 이름, 나이, 취미, 기타 정보를 받아서 자기소개를 출력하고, 마지막에 소개가 완료되었다는 메시지를 돌려줍니다.

1단계: 함수 호출될 때 값되는 값들

result = introduce(
    "Eunice",  # name → "Eunice"
    25,   # age → 25
    "독서", "여행", "코딩", # *hobbies → ("독서", "여행", "코딩")
    job="개발자", city="서울" # **info → {"job": "개발자", "city": "서울"}
)

이렇게 전달된 값들은 아래처럼 함수 안에서 변수로 정리됩니다:

• name = "Eunice"
• age = 25
• hobbies = ("독서", "여행", "코딩") ← 튜플
• info = {"job": "개발자", "city": "서울"} ← 딕셔너리

2단계: 이름과 나이 출력

print("이름:", name)    # 이름: Eunice
print("나이:", age)     # 나이: 25

• 취미 출력 (반복문)

for hobby in hobbies:
    print("-", hobby)

• 첫 번째 반복: "독서" → 출력: - 독서

• 두 번째 반복: "여행" → 출력: - 여행

• 세 번째 반복: "코딩" → 출력: - 코딩

• 기타 정보 출력 (딕셔너리 순회)

for key, value in info.items():
    print(f"{key}: {value}")

• "job" → "개발자" → 출력: job: 개발자
• "city" → "서울" → 출력: city: 서울

3단계: 함수가 실행된 후 결과값(return)이 돌아감

return f"{name}님의 소개가 완료되었습니다!"

• "Eunice님의 소개가 완료되었습니다!" → 이 값이 result 변수에 저장됨

4단계: 최종 출력

print("함수의 반환값:", result)

🖨️ 출력 결과:

이름: Eunice
나이: 25
취미 목록:
- 독서
- 여행
- 코딩
기타 정보:
job: 개발자
city: 서울
함수의 반환값: Eunice님의 소개가 완료되었습니다!

📝 문제 1] 동물 소개 함수 만들기 introduce_animal() 함수는

• 필수 정보로 이름(name),
• 기본값 정보로 종류(species, 기본값은 "강아지"),
• 가변 인자로 특징들(*features),
• 가변 키워드 인자로 추가 정보(**details)를 받습니다. 반환 메시지는 "OOO(종류)의 소개가 완료되었습니다." 형식으로 하세요.

result = introduce_animal("초코", "고양이", "귀여움", "애교 많음", color="갈색", age=2)
print("리턴 메시지:", result)

🖨️ 출력 결과:

이름: 초코
종류: 고양이
특징:
- 귀여움
- 애교 많음
추가 정보:
color: 갈색
age: 2
리턴 메시지: 초코(고양이)의 소개가 완료되었습니다.

✅ 정답 코드:

def introduce_animal(name, species="강아지", *features, **details):
    print("이름:", name)
    print("종류:", species)
    
    print("특징:")
    for feature in features:
        print("-", feature)
    
    print("추가 정보:")
    for key, value in details.items():
        print(f"{key}: {value}")
    
    return f"{name}({species})의 소개가 완료되었습니다."

result = introduce_animal("초코", "고양이", "귀여움", "애교 많음", color="갈색", age=2)
print("리턴 메시지:", result)

🔍 해설:

• species는 기본값을 제공하므로 생략 가능
• *features는 "귀여움", "애교 많음"을 튜플로 받아 출력
• **details는 color, age를 딕셔너리로 받아 출력
• return을 사용해 마지막 메시지를 리턴하고, result 변수로 받아 출력

📝 문제 2] 온라인 수강생 정보 관리 함수 register_student() 함수는

• 필수 정보로 이름(name)을 받고,
• 기본값으로 학년(grade, 기본은 "1학년"),
• 가변 인자로 수강 과목 리스트(*subjects),
• 가변 키워드 인자로 이메일, 지역 등의 추가 정보(**info)를 받습니다.

요구 조건:

• 과목 수가 없을 경우 "수강 과목 없음"이라고 출력
• 추가 정보가 없을 경우 "추가 정보 없음" 출력
• 리턴값은 "OOO님의 수강신청이 완료되었습니다. (총 과목 수: N개)"

msg = register_student("다현", "3학년", "수학", "영어", email="dahyun@example.com", region="서울")
print("리턴 메시지:", msg)

🖨️ 출력 결과:

이름: 다현
학년: 3학년
수강 과목:
- 수학
- 영어
추가 정보:
email: dahyun@example.com
region: 서울
리턴 메시지: 다현님의 수강신청이 완료되었습니다. (총 과목 수: 2개)

✅ 정답 코드:

def register_student(name, grade="1학년", *subjects, **info):
    print("이름:", name)
    print("학년:", grade)

    if subjects:
        print("수강 과목:")
        for subject in subjects:
            print("-", subject)
    else:
        print("수강 과목 없음")

    if info:
        print("추가 정보:")
        for key, value in info.items():
            print(f"{key}: {value}")
    else:
        print("추가 정보 없음")
    
    return f"{name}님의 수강신청이 완료되었습니다. (총 과목 수: {len(subjects)}개)"

msg = register_student("다현", "3학년", "수학", "영어", email="dahyun@example.com", region="서울")
print("리턴 메시지:", msg)

🔍 해설:

• *subjects가 비어 있으면 출력 대신 "수강 과목 없음" 처리
• **info도 없을 경우 "추가 정보 없음" 처리
• len(subjects)로 수강 과목 개수를 계산하여 메시지에 반영
• 실무 상황을 반영한 조건 처리 + 다양한 매개변수 조합 훈련 문제입니다.

◽ return을 사용해 값을 반환하는 함수의 개념

</> 함수정의:

def return_test():
    return 100

🔍 코드 해설

• def return_test():

  • return_test라는 이름의 함수를 정의합니다.
  • 괄호 안이 비어 있으므로 입력값은 필요 없습니다.

• return 100

  • 이 함수가 실행되면 숫자 100을 결과로 돌려줍니다.
  • return은 함수의 "출력값" 또는 "결과값"을 외부에 전달하는 역할을 합니다.

</> 함수호출:

value = return_test()

🔍 동작 설명

• return_test()를 실행하면 내부의 return 100이 실행됩니다.
• 이 결과값 100이 value라는 변수에 저장됩니다.

</> print 결과출력:

print(value)

• value 변수에 저장된 값은 100

🖨️ 출력 결과

100

◽ start부터 end까지의 숫자를 모두 더하는 함수 sum_all()

</> 함수정의:

def sum_all(start, end):
    output = 0
    for i in range(start, end + 1):
        output += i
    return output

🔍 코드 해설 (한 줄씩) def sum_all(start, end): start: 시작 숫자 end: 끝 숫자 이 함수는 start부터 end까지의 숫자를 모두 더해서 돌려주는 함수입니다.

output = 0 결과값을 저장할 변수입니다. 처음에는 0으로 시작하고, 하나씩 더하면서 누적해요.

for i in range(start, end + 1): range(start, end + 1)은 start부터 end까지의 숫자를 만들어줍니다. +1을 하는 이유는 range() 함수가 끝 숫자 직전까지만 포함하기 때문입니다.

output += i output = output + i의 축약형 반복될 때마다 숫자 i를 output에 계속 더해갑니다.

return output 반복이 끝난 후, 최종 합계인 output 값을 함수 결과로 돌려줍니다.

</> 함수 호출 예시 및 결과:

print("0 to 100:", sum_all(0, 100))    # 출력: 0 to 100: 5050
print("0 to 1000:", sum_all(0, 1000))   # 출력: 0 to 1000: 500500
print("50 to 100:", sum_all(50, 100))    # 출력: 50 to 100: 3825
print("500 to 1000:", sum_all(500, 1000)) # 출력: 500 to 1000: 375250

◽ 기본 매개변수와 키워드 인자를 활용한 sum_all() 함수의 동작 원리

</> 함수 정의:

def sum_all(start=0, end=100, step=1):
    output = 0
    for i in range(start, end + 1, step):
        output += i
    return output

🔍 함수 설명

• start=0: 더하기를 시작할 숫자 (기본값: 0)
• end=100: 어디까지 더할지 정하는 숫자 (기본값: 100)
• step=1: 몇 칸씩 건너뛸지 정하는 간격 (기본값: 1)

💡 기본 매개변수: 값을 생략하면 기본값이 자동으로 사용됩니다. 💡 키워드 인자: start=0처럼 매개변수 이름을 직접 지정해 전달하면 순서를 바꿔도 동작합니다.

✅ 함수 호출 예시와 출력 결과

1️⃣ sum_all(0, 100, 10)

• start=0, end=100, step=10
• 0부터 100까지 10씩 증가하며 더함
  더해지는 수: 0 + 10 + 20 + ... + 100 = 550

print("A.", sum_all(0, 100, 10))  
# 출력 → A. 550

2️⃣ sum_all(end=100)

• start와 step 생략 → 기본값 사용됨 (start=0, step=1)
• 0부터 100까지 1씩 더함
  더해지는 수: 0 + 1 + 2 + ... + 100 = 5050

print("B.", sum_all(end=100))  
# 출력 → B. 5050

3️⃣ sum_all(end=100, step=2)

• start 생략 → 기본값 start=0
• 0부터 100까지 2씩 증가하며 더함 → 짝수만 더함
  더해지는 수: 0 + 2 + 4 + ... + 100 = 2550

print("C.", sum_all(end=100, step=2))  
# 출력 → C. 2550

◽ print_n_times() 함수의 동작 원리와 구조

</> 함수 정의:

def print_n_times(n, *values):
    for i in range(n):
        for value in values:
            print(value)
        print()  # 줄바꿈

🔍 코드 해설 (블릿 설명) def print_n_times(n, *values): n: 몇 번 반복할지 정하는 숫자형 매개변수 *values: 여러 개의 문자열을 한꺼번에 받을 수 있는 가변 매개변수 내부에서 튜플처럼 동작, 여러 개의 값을 묶어서 받음

for i in range(n): 0부터 n-1까지 총 n번 반복합니다.

for value in values: 전달된 여러 문장(values)을 하나씩 꺼내서 출력합니다.

print(value) 꺼낸 문장을 화면에 출력합니다.

print() 각 묶음 출력이 끝난 뒤 줄바꿈을 해줍니다.

</> 함수 호출:

print_n_times(3, "안녕하세요", "즐거운", "파이썬 프로그래밍")

• n = 3 → 전체 문장 묶음을 3번 반복
• "안녕하세요", "즐거운", "파이썬 프로그래밍" → 한 번에 출력할 문장들

🖨️ 출력 결과:

안녕하세요
즐거운
파이썬 프로그래밍

안녕하세요
즐거운
파이썬 프로그래밍

안녕하세요
즐거운
파이썬 프로그래밍

💭직접 풀어보세요.

📝 문제1] 기본값 매개변수 사용하기 greet() 함수는 이름을 인사하는 함수입니다.
이름을 전달하지 않으면 기본으로 "친구"라고 인사하게 만들어보세요.

🖨️ 출력결과:

안녕하세요, 민수님!
안녕하세요, 친구님!

✅ 정답:

def greet(name="친구"):
    print(f"안녕하세요, {name}님!")

greet("민수")
greet()

🔍 해설:

• name="친구"는 기본값 매개변수입니다.
• 인자를 전달하면 전달한 값으로, 전달하지 않으면 "친구"로 동작합니다.

📝 문제2] 키워드 인자 사용하기 함수를 호출할 때 키워드 인자를 사용해 순서와 상관없이 값을 지정하세요.

🖨️ 출력결과:

이름: 수지, 나이: 30

✅ 정답:

def show_info(name, age):
    print(f"이름: {name}, 나이: {age}")

show_info(age=30, name="수지")

🔍 해설:

• name="수지"처럼 키워드 인자를 사용하면 순서와 무관하게 전달할 수 있습니다.
• 실무에서 API 호출 시 가독성이 좋아 선호됩니다.

📝 문제3] 가변 인자 (*args) 사용하기 여러 명의 이름을 받아 인사하는 함수를 만들어보세요.

🖨️ 출력결과:

안녕하세요, 영희님!
안녕하세요, 철수님!
안녕하세요, 민수님!

✅ 정답:

def greet_all(*names):
    for name in names:
        print(f"안녕하세요, {name}님!")

greet_all("영희", "철수", "민수")

🔍 해설:

• *names는 가변 인자로 여러 개의 값을 튜플로 받아옵니다.
• 인자의 수가 정해져 있지 않을 때 유용하게 사용됩니다.

📝 문제4] 가변 키워드 인자 (**kwargs) 사용하기 사용자의 정보를 받아 키:값 형태로 모두 출력해보세요.

🖨️ 출력결과:

username: kim99
email: kim@example.com
age: 28

✅ 정답:

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(username="kim99", email="kim@example.com", age=28)

🔍 해설:

• **kwargs는 가변 키워드 인자로 딕셔너리 형태의 인자를 받아옵니다.
• 실무에서 다양한 필드 값을 처리할 때 자주 사용됩니다.

📝 문제5] 함수 정의와 반환값 활용하기 숫자 두 개를 받아 큰 수를 반환하는 함수를 작성하세요.

🖨️ 출력결과:

더 큰 수는: 42

✅ 정답:

def get_max(a, b):
    if a > b:
        return a
    else:
        return b

result = get_max(42, 18)
print("더 큰 수는:", result

🔍 해설:

• return 문은 결과값을 함수 밖으로 전달합니다.
• 실무에서는 처리한 데이터를 리턴하여 다른 곳에서 재사용합니다.

📝 문제6] 함수 안에서 다른 함수 호출하기 할인 계산을 하는 함수와 그 결과를 보여주는 함수를 각각 만들고, 호출 흐름을 구성하세요.

🖨️ 출력결과:

할인된 가격은 7200원입니다.

✅ 정답:

def calculate_discount(price, rate):
    return price * (1 - rate)

def print_discounted_price(price, rate):
    discounted = calculate_discount(price, rate)
    print(f"할인된 가격은 {int(discounted)}원입니다.")

print_discounted_price(8000, 0.1)

🔍 해설:

• calculate_discount()는 계산만 담당하고, print_discounted_price()는 출력 담당입니다.
• 함수 간 역할 분리로 코드 재사용성과 유지보수성이 높아집니다.

📝 문제7] 기본값 매개변수와 인자의 관계 아래의 함수는 사용자의 이름과 취미를 출력합니다.
취미가 전달되지 않으면 "독서"를 기본값으로 출력되도록 코드를 완성하세요.

🖨️ 출력결과:

이름: 영희, 취미: 독서
이름: 철수, 취미: 등산

✅ 정답:

def introduce(name, hobby="독서"):
    print(f"이름: {name}, 취미: {hobby}")

introduce("영희")
introduce("철수", "등산")

🔍 해설:

• 함수 introduce()는 두 개의 매개변수를 받습니다. name은 필수 매개변수이고, hobby는 "독서"라는 기본값이 지정된 매개변수입니다.
• introduce("영희")는 취미를 전달하지 않았기 때문에, 기본값 "독서"가 자동으로 사용됩니다.
• 반면 introduce("철수", "등산")처럼 두 번째 인자를 명시적으로 전달하면, 기본값은 무시되고 "등산"이 사용됩니다.
• 이처럼 기본값 매개변수는 인자가 전달되지 않았을 때만 적용되며, 전달된 인자가 있으면 해당 값이 우선 사용됩니다.

📝 문제8] 함수 호출과 리턴값 응용 두 개의 숫자를 받아 차이의 절댓값을 반환하는 함수를 작성하세요.
단, 어떤 숫자를 먼저 입력해도 항상 양수가 나오게 하세요.

🖨️ 출력결과:

두 수의 차이: 3
두 수의 차이: 7

✅ 정답:

def difference(a, b):
    return abs(a - b)

print("두 수의 차이:", difference(5, 8))
print("두 수의 차이:", difference(10, 3))

🔍 해설:

• difference() 함수는 두 개의 숫자 a, b를 매개변수로 받아, 그 차이의 절댓값을 반환합니다.
• abs() 함수는 파이썬 내장 함수로, 어떤 숫자가 음수든 양수든 항상 양수로 반환해줍니다.
• difference(5, 8)의 경우 5 - 8 = -3이지만, abs()를 통해 양수 3이 반환됩니다.
• difference(10, 3)은 10 - 3 = 7이므로 그대로 7이 반환됩니다.
• 이처럼 abs()를 사용하면 입력 순서에 관계없이 항상 양수 결과를 보장할 수 있으며,
  함수는 계산만 수행하고 print()는 호출한 위치에서 결과를 출력하는 방식으로 역할 분리도 잘 되어 있습니다.

📝 문제9] 키워드 인자와 위치 인자 혼합 사용 사용자의 이름과 직업을 출력하는 함수입니다.
직업은 키워드 인자로 전달하고, 이름은 위치 인자로 전달되도록 코드를 작성하세요.

🖨️ 출력결과:

이름: 지민, 직업: 개발자
이름: 수빈, 직업: 디자이너

✅ 정답:

def profile(name, job):
    print(f"이름: {name}, 직업: {job}")

profile("지민", job="개발자")
profile("수빈", job="디자이너")

🔍 해설:

• 함수 profile()은 name과 job 두 개의 매개변수를 가집니다.
• name은 위치 인자(positional argument)로, 함수를 호출할 때 값이 순서대로 전달됩니다.
• job은 키워드 인자(keyword argument)로, 호출 시 job="개발자"처럼 이름을 지정해서 전달합니다.
• profile("지민", job="개발자")에서 "지민"은 첫 번째 위치 인자로 name에 들어가고, "개발자"는 키워드 인자로 job에 들어갑니다.
• 이처럼 위치 인자와 키워드 인자를 혼합하여 사용하면, 코드의 가독성이 좋아지고 인자 전달 순서에 대한 유연성도 확보됩니다.

📝 문제10] 가변 인자 사용해 평균 구하기 숫자를 여러 개 받아 평균값을 반환하는 함수를 작성하세요.
숫자는 몇 개가 들어올지 모르므로 가변 인자를 사용해야 합니다.

🖨️ 출력결과:

평균: 20.0
평균: 35.0

✅ 정답:

def get_average(*nums):
    total = sum(nums)
    count = len(nums)
    return total / count

print("평균:", get_average(10, 20, 30))
print("평균:", get_average(40, 30, 35))

🔍 해설:

• 함수 get_average()는 *nums라는 가변 인자를 사용하여, 몇 개의 숫자가 들어올지 모를 상황에서도 유연하게 처리할 수 있도록 설계되었습니다.
• *nums는 전달된 인자들을 튜플 형태로 받아들여, sum()과 len()을 통해 총합과 개수를 계산합니다.
• return total / count는 총합을 개수로 나누어 평균값을 반환합니다.
• get_average(10, 20, 30) 호출 시 nums = (10, 20, 30)이 되고, 평균은 (10 + 20 + 30) / 3 = 20.0
• get_average(40, 30, 35) 호출 시 평균은 (40 + 30 + 35) / 3 = 35.0

📝 문제12] 가변 키워드 인자를 활용한 유저 정보 출력 사용자 정보를 전달받아 key: value 형태로 모두 출력하는 함수를 작성하세요.
딕셔너리 형태로 데이터를 받아 처리하세요.

🖨️ 출력결과:

name: 민준
email: minjun@example.com
location: Seoul

✅ 정답:

def show_user_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

show_user_info(name="민준", email="minjun@example.com", location="Seoul")

🔍 해설:

• 함수 show_user_info()는 **info라는 가변 키워드 인자를 사용합니다.
• **info는 호출 시 전달된 key=value 형식의 인자들을 딕셔너리 형태로 받아들입니다.
• for key, value in info.items()를 통해 각 키-값 쌍을 순회하면서 key: value 형식으로 출력합니다.
• show_user_info(name="민준", email="minjun@example.com", location="Seoul") 호출 시,
  내부적으로 info = {"name": "민준", "email": "minjun@example.com", "location": "Seoul"}와 같은 딕셔너리가 전달됩니다.

📝 문제12] 함수 내부에서 다른 함수를 호출하여 구성 가격과 할인율을 받아 할인된 가격을 계산하고,
그 결과를 출력하는 두 개의 함수를 정의하고 호출 흐름을 완성하세요.

🖨️ 출력결과:

최종 결제 금액은 18000원입니다.

✅ 정답:

def apply_discount(price, rate):
    return price * (1 - rate)

def print_final_price(price, rate):
    final_price = apply_discount(price, rate)
    print(f"최종 결제 금액은 {int(final_price)}원입니다.")

print_final_price(20000, 0.1)

🔍 해설:

• apply_discount() 함수는 할인 계산 로직만 담당하며, price * (1 - rate)를 계산하여 결과를 반환합니다.
  예를 들어 20000 * (1 - 0.1) = 18000.0이 계산됩니다.
• print_final_price() 함수는 할인된 가격을 계산하기 위해 apply_discount()를 내부에서 호출하고,
  반환된 값을 정수로 변환한 뒤 출력합니다.
• print_final_price(20000, 0.1) 호출 시 두 함수가 순차적으로 실행되며, 계산과 출력이 함수별로 분리되어 있어 코드가 명확하고 재사용이 용이합니다.

📝 문제13] 함수 정의와 호출 이름과 나이를 전달받아 소개 메시지를 출력하는 함수를 정의하고 호출하세요.
단, 함수 이름은 introduce_person으로 하세요.

🖨️ 출력결과:

안녕하세요, 저는 철수이고 25살입니다.

✅ 정답:

def introduce_person(name, age):
    print(f"안녕하세요, 저는 {name}이고 {age}살입니다.")

introduce_person("철수", 25)

🔍 해설:

• introduce_person() 함수는 name과 age라는 두 개의 매개변수를 정의하고, 이를 사용해 소개 메시지를 출력합니다.
• 함수 내부의 print()는 f-string을 사용하여 name과 age 값을 문자열에 삽입합니다.
• introduce_person("철수", 25)는 "철수"를 name, 25를 age에 전달하여 실행됩니다.

📝 문제14] 기본값 매개변수 활용 도시 이름을 출력하는 함수를 만드세요.
도시를 전달하지 않으면 기본값으로 "서울"이 출력되도록 하세요.

🖨️ 출력결과:

사는 곳: 부산
사는 곳: 서울

✅ 정답:

def show_city(city="서울"):
    print(f"사는 곳: {city}")

show_city("부산")
show_city()

🔍 해설:

• show_city() 함수는 하나의 매개변수 city를 가지며, 기본값으로 "서울"이 설정되어 있습니다.
• show_city("부산")처럼 인자를 전달하면, 전달된 "부산"이 city 매개변수에 적용되어 출력됩니다.
• 반면 show_city()처럼 인자를 생략하면, 기본값 "서울"이 자동으로 사용되어 "사는 곳: 서울"이 출력됩니다.

📝 문제15] 키워드 인자와 위치 인자 혼합 음식 이름과 가격을 출력하는 함수를 정의하고,
위치는 위치 인자로, 가격은 키워드 인자로 호출하도록 하세요.

🖨️ 출력결과:

메뉴: 김밥, 가격: 3000원
메뉴: 라면, 가격: 4000원

✅ 정답:

def menu_item(name, price):
    print(f"메뉴: {name}, 가격: {price}원")

menu_item("김밥", price=3000)
menu_item("라면", price=4000)

🔍 해설:

• menu_item() 함수는 두 개의 매개변수 name과 price를 받아, 메뉴 이름과 가격 정보를 출력합니다.
• 함수 내부에서는 f-string을 사용하여 "메뉴: 김밥, 가격: 3000원"처럼 보기 좋게 문자열을 구성합니다.
• menu_item("김밥", price=3000)처럼 호출 시, "김밥"은 위치 인자로 name에, price=3000은 키워드 인자로 price에 전달됩니다.
• 이처럼 위치 인자와 키워드 인자를 혼합 사용하면, 가독성이 높아지고 인자 전달의 명확성이 증가합니다.

📝 문제16] 가변 인자 사용하기 (*args) 숫자를 여러 개 받아 모두 곱한 결과를 반환하는 함수를 정의하세요.
숫자의 개수는 정해져 있지 않습니다.

🖨️ 출력결과:

결과: 24
결과: 120

✅ 정답:

def multiply_all(*nums):
    result = 1
    for n in nums:
        result *= n
    return result

print("결과:", multiply_all(2, 3, 4))
print("결과:", multiply_all(1, 2, 3, 4, 5))

🔍 해설:

• multiply_all() 함수는 *nums를 사용해 가변 인자를 받습니다.
  즉, 인자의 개수가 몇 개가 들어오든 튜플 형태로 처리할 수 있습니다.
• result = 1: 곱셈을 위해 초기값을 1로 설정합니다.
• for n in nums:
  전달된 모든 숫자를 하나씩 꺼내서 result에 곱해 나갑니다.
  예를 들어 multiply_all(2, 3, 4)의 경우,
  2 * 3 * 4 = 24가 계산됩니다.
• return result: 최종 곱셈 결과를 반환합니다.

📝 문제17] 가변 키워드 인자 활용 (**kwargs) 학생의 정보를 받아 "이름: 값" 형태로 모두 출력하는 함수를 작성하세요.
입력값은 이름, 학년, 반, 점수 등이 될 수 있습니다.

🖨️ 출력결과:

이름: 수지
학년: 3
반: 2
점수: 95

✅ 정답:

def student_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

student_info(이름="수지", 학년=3, 반=2, 점수=95)

🔍 해설:

📝 문제18] 함수 안에서 리턴값을 활용하는 구조 만들기 두 숫자를 전달받아 합계를 구하고, 그 결과를 출력하는 2개의 함수를 작성하세요.

• 하나는 add_numbers(a, b)
• 다른 하나는 print_result(a, b)

🖨️ 출력결과:

두 수의 합은 17입니다.

✅ 정답:

def add_numbers(a, b):
    return a + b

def print_result(a, b):
    total = add_numbers(a, b)
    print(f"두 수의 합은 {total}입니다.")

print_result(8, 9)

🔍 해설:

• student_info(**kwargs) 함수는 가변 키워드 인자를 사용하여 호출 시 전달된 키워드 인자들을 하나의 딕셔너리로 받습니다.
  즉, 이름="수지", 학년=3, 반=2, 점수=95는 함수 내부에서
  kwargs = {"이름": "수지", "학년": 3, "반": 2, "점수": 95} 형태로 처리됩니다.
• for key, value in kwargs.items():
  딕셔너리의 각 키와 값을 순회하면서 출력합니다.
  결과적으로 각 항목이 key: value 형식으로 화면에 출력됩니다.

📝 문제19] 매개변수와 인자 이해하기 이름과 직업을 전달받아 자기소개를 출력하는 introduce 함수를 만드세요.

🖨️ 출력결과:

저는 수연이고, 직업은 디자이너입니다.

✅ 정답:

def introduce(name, job):
    print(f"저는 {name}이고, 직업은 {job}입니다.")

introduce("수연", "디자이너")

📝 문제20] 기본값 매개변수

🖨️ 출력결과:

이름: 준호, 국적: 대한민국
이름: 아미, 국적: 일본

✅ 정답:

def user_info(name, nation="대한민국"):
    print(f"이름: {name}, 국적: {nation}")

user_info("준호")
user_info("아미", "일본")

📝 문제21] 키워드 인자 사용 아래와 같이 출력되도록, 함수를 정의하고 호출 코드를 작성하세요.
순서를 바꿔 호출하되, 올바르게 작동해야 합니다.

🖨️ 출력결과:

이름: 태형, 취미: 사진

✅ 정답:

def hobby_info(name, hobby):
    print(f"이름: {name}, 취미: {hobby}")

hobby_info(hobby="사진", name="태형")

📝 문제22] 가변 인자 사용하기 (*args) 여러 개의 과일 이름을 받아 한 줄에 모두 출력하는 함수를 작성하세요.
과일 이름은 몇 개가 들어올지 알 수 없습니다.

🖨️ 출력결과:

선택한 과일: 사과, 바나나, 키위

✅ 정답:

def print_fruits(*fruits):
    print("선택한 과일:", ", ".join(fruits))

print_fruits("사과", "바나나", "키위")

🔍 해설:

• print_fruits(*fruits) 함수는 가변 인자** *fruits를 사용하여, 전달된 과일 이름들을 튜플 형태로 수집합니다.
  예를 들어 print_fruits("사과", "바나나", "키위") 호출 시,
  fruits = ("사과", "바나나", "키위")가 됩니다.
• ", ".join(fruits)는 문자열 메서드로,
  튜플에 담긴 과일 이름들을 쉼표와 공백(“, ”)으로 연결해 하나의 문자열로 만듭니다.

📝 문제23] 가변 키워드 인자 (**kwargs)로 제품 상세 정보 출력 제품의 정보(제품명, 가격, 제조사 등)를 받아 출력하는 함수를 작성하세요.
항목 수는 바뀔 수 있습니다.

🖨️ 출력결과:

제품명: 무선마우스
가격: 25000
제조사: 로지텍

✅ 정답:

def product_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

product_info(제품명="무선마우스", 가격=25000, 제조사="로지텍")

🔍 해설:

• product_info(**kwargs) 함수는 가변 키워드 인자를 사용하여, 호출 시 전달된 key=value 형식의 인자들을 딕셔너리 형태로 수집합니다.
• for key, value in kwargs.items():는 딕셔너리의 모든 항목을 순회하면서, key: value 형식으로 출력합니다.

📝 문제24] 계산기 기능 함수로 분리 두 수와 연산 기호('+', '-')를 받아 계산하는 함수를 정의하세요.
함수 이름은 calculate, 결과를 출력하는 함수는 show_result입니다.

🖨️ 출력결과:

결과: 15
결과: 3

✅ 정답:

def calculate(a, b, operator):
    if operator == "+":
        return a + b
    elif operator == "-":
        return a - b
    else:
        return "지원하지 않는 연산자입니다."

def show_result(a, b, op):
    result = calculate(a, b, op)
    print("결과:", result)

show_result(10, 5, "+")
show_result(7, 4, "-")

🔍 해설:

• calculate(a, b, operator)
  • 숫자 a와 b, 연산자 기호 operator를 받아 계산 수행
  • "+"면 덧셈, "-"면 뺄셈 수행
  • 그 외의 연산자는 "지원하지 않는 연산자입니다." 메시지 반환
• show_result(a, b, op)
  • calculate() 함수를 호출하여 결과를 받고 출력
  • 결과는 "결과: 값" 형태로 출력됨
• show_result(10, 5, "+") → "결과: 15" 출력
• show_result(7, 4, "-") → "결과: 3" 출력

📝 문제25] 함수 정의와 호출, 반환값 두 개의 숫자를 더한 결과를 반환하는 함수를 작성하고, 그 결과를 출력하세요.
함수 이름은 add_numbers로 정의하세요.

🖨️ 출력결과:

합계: 13

✅ 정답:

def add_numbers(a, b):
    return a + b

result = add_numbers(5, 8)
print("합계:", result)

📝 문제26] 기본값 매개변수를 활용한 인사 함수 사용자의 이름과 인사말을 출력하는 함수를 작성하세요.
인사말을 생략하면 기본값으로 "안녕하세요"가 사용되도록 하세요.

🖨️ 출력결과:

수빈님, 안녕하세요!
민수님, 반갑습니다!

✅ 정답:

def greeting(name, message="안녕하세요"):
    print(f"{name}님, {message}!")

greeting("수빈")
greeting("민수", "반갑습니다")

📝 문제27] 키워드 인자를 사용해 순서를 바꿔도 올바르게 출력 상품명과 가격을 출력하는 함수를 만들고, 키워드 인자를 사용하여 순서와 상관없이 값을 전달해보세요.

🖨️ 출력결과:

상품명: 무선이어폰
가격: 129000원

✅ 정답:

def show_product(name, price):
    print(f"상품명: {name}")
    print(f"가격: {price}원")

show_product(price=129000, name="무선이어폰")

📝 문제28] 가변 인자(*args)로 여러 숫자 더하기 입력된 숫자들을 모두 더한 합을 출력하는 함수를 작성하세요.
숫자의 개수는 정해져 있지 않습니다.

🖨️ 출력결과:

총합: 27

✅ 정답:

def sum_all(*numbers):
    total = sum(numbers)
    print("총합:", total)

sum_all(3, 5, 7, 12)

📝 문제29] 가변 키워드 인자(**kwargs)로 사용자 프로필 출력 이름, 나이, 이메일 등의 정보를 받아 모두 출력하는 함수를 작성하세요.
입력 항목은 사용자마다 다를 수 있습니다.

🖨️ 출력결과:

이름: 지훈
이메일: jihoon@example.com
나이: 29

✅ 정답:

def print_profile(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_profile(이름="지훈", 이메일="jihoon@example.com", 나이=29)

🔍 해설:

• print_profile(**kwargs)
  • 가변 키워드 인자를 사용하여 key=value 형식의 여러 정보를 딕셔너리로 받음
  • 예: kwargs = {"이름": "지훈", "이메일": "jihoon@example.com", "나이": 29}
• for key, value in kwargs.items():
  • 딕셔너리의 모든 항목을 순회하면서 key: value 형태로 출력

📝 문제30] 조건에 따라 서로 다른 메시지를 반환하는 함수 사용자의 나이를 입력받아 다음 기준에 따라 다른 메시지를 반환하는 함수를 작성하세요.

• 19세 미만이면 "미성년자입니다."
• 65세 이상이면 "노년층입니다."
• 그렇지 않으면 "성인입니다."

🖨️ 출력결과:

결과: 성인입니다.
결과: 노년층입니다.

✅ 정답:

def check_age(age):
    if age < 19:
        return "미성년자입니다."
    elif age >= 65:
        return "노년층입니다."
    else:
        return "성인입니다."

print("결과:", check_age(32))
print("결과:", check_age(70))